/*
 * Ext JS Library 2.0 Alpha 1
 * Copyright(c) 2006-2007, Ext JS, LLC.
 * licensing@extjs.com
 *
 * http://extjs.com/license
 */

Ext.Desktop = function() {
    var desktop = Ext.get('x-desktop');
    var taskbar = Ext.get('x-taskbar');
    var wbar = Ext.get('x-windows');

    var windows = new Ext.WindowGroup();
    var activeWindow;

    function minimizeWin(win) {
        win.minimized = true;
        win.hide();
    }

    function markActive(win) {
        if (activeWindow && activeWindow != win) {
            markInactive(activeWindow);
        }
        activeWindow = win;
        Ext.fly(win.taskItem.el).addClass('active-win');
        win.minimized = false;
    }

    function markInactive(win) {
        if (win == activeWindow) {
            activeWindow = null;
            Ext.fly(win.taskItem.el).removeClass('active-win');
        }
    }

    function removeWin(win) {
        win.taskItem.destroy();
        layout();
    }

    function layout() {
        desktop.setHeight(Ext.lib.Dom.getViewHeight() - (taskbar ? taskbar.getHeight() : 0) - wbar.getHeight());
    }
    Ext.EventManager.onWindowResize(layout);

    this.layout = layout;

    this.createWindow = function(config, cls) {
        var win = new (cls || Ext.Window)(
                Ext.applyIf(config || {}, {
                    manager: windows,
                    constrainHeader: true,
                    minimizable: true,
                    maximizable: true
                })
                );
        win.render(desktop);
        win.taskItem = new Ext.Desktop.TaskBarItem(win);

        win.cmenu = new Ext.menu.Menu({
            items: [

                    ]
        });

        win.animateTarget = win.taskItem.el;
        win.on('activate', markActive);
        win.on('beforeshow', markActive);
        win.on('deactivate', markInactive);
        win.on('minimize', minimizeWin);
        win.on('close', removeWin);
        layout();
        return win;
    };

    this.getManager = function() {
        return windows;
    };

    this.getWindow = function(id) {
        return windows.get(id);
    }

    layout();
};

Ext.Desktop.TaskBarItem = function(win) {
    this.win = win;
    Ext.Desktop.TaskBarItem.superclass.constructor.call(this, {
        iconCls: win.iconCls,
        text: win.title,
        renderTo: 'x-winlist',
        handler : function() {
            if (win.minimized || win.hidden) {
                win.show();
            } else if (win == win.manager.getActive()) {
                win.minimize();
            } else {
                win.toFront();
            }
        },
        clickEvent:'mousedown'
    });
};

Ext.extend(Ext.Desktop.TaskBarItem, Ext.Button, {
    onRender : function() {
        Ext.Desktop.TaskBarItem.superclass.onRender.apply(this, arguments);

        this.cmenu = new Ext.menu.Menu({
            items: [{
                text: 'Restore',
                handler: function() {
                    if (!this.win.isVisible()) {
                        this.win.show();
                    } else {
                        this.win.restore();
                    }
                },
                scope: this
            },{
                text: 'Minimize',
                handler: this.win.minimize,
                scope: this.win
            },{
                text: 'Maximize',
                handler: this.win.maximize,
                scope: this.win
            }, '-', {
                text: 'Close',
                handler: this.win.close,
                scope: this.win
            }]
        });

        this.cmenu.on('beforeshow', function() {
            var items = this.cmenu.items.items;
            var w = this.win;
            items[0].setDisabled(w.maximized !== true && w.hidden !== true);
            items[1].setDisabled(w.minimized === true);
            items[2].setDisabled(w.maximized === true || w.hidden === true);
        }, this);

        this.el.on('contextmenu', function(e) {
            e.stopEvent();
            if (!this.cmenu.el) {
                this.cmenu.render();
            }
            var xy = e.getXY();
            xy[1] -= this.cmenu.el.getHeight();
            this.cmenu.showAt(xy);
        }, this);
    }
});


Ext.app.App = function(cfg) {
    Ext.apply(this, cfg);
    this.addEvents({
        'ready' : true,
        'beforeunload' : true,
        'sessionexpire': true
    });

    Ext.onReady(this.initApp, this);
};

Ext.extend(Ext.app.App, Ext.util.Observable, {
    isReady: false,

    modules : [],

    getModuleById : function(id) {
        for (var i=0; i<this.modules.length; i++) {
            if (id == this.modules[i].getId()) {
                return this.modules[i];
            }
        }
    },

    initApp : function() {
        this.desktop = new Ext.Desktop();
        this.launcher = new Ext.Toolbar({renderTo:'x-launcher'});
        this.modules = this.getModules();
        if (this.modules) {
            this.initModules(this.modules);
        }

        this.init();

        Ext.EventManager.on(window, 'beforeunload', this.onUnload, this);
        this.fireEvent('ready', this);
        this.isReady = true;
    },

    getModules : Ext.emptyFn,
    init : Ext.emptyFn,

    initModules : function(ms) {
        for (var i = 0, len = ms.length; i < len; i++) {
            var m = ms[i];
            this.launcher.add(m.launcher);
            m.app = this;
        }
    },

    onReady : function(fn, scope) {
        if (!this.isReady) {
            this.on('ready', fn, scope);
        } else {
            fn.call(scope, this);
        }
    },

    getDesktop : function() {
        return this.desktop;
    },

    onUnload : function(e) {
        if (this.fireEvent('beforeunload', this) === false) {
            e.stopEvent();
        }
    }
});


Ext.app.Module = function(config) {
    Ext.apply(this, config);
    Ext.app.Module.superclass.constructor.call(this);
    this.init();
}

Ext.extend(Ext.app.Module, Ext.util.Observable, {
    init : function() {

    },
    getId : function() {

    },
    getParamId : function() {

    },
    loadData : function() {

    }
});

DojoManager = new Ext.app.App({
    init :function() {
        Ext.QuickTips.init();

        var app = this;
        var ms = this.modules;
        var desktop = this.getDesktop();
        refreshCallback = function() {
            var mng =  desktop.getManager();
            var wins = mng.getBy(function(w) {
                if (!w.hidden) {
                    return true
                } else {
                    return false
                }
            });
            var winsId = [];
            var m = {};
            for (var i=0; i<wins.length; i++) {
                m = app.getModuleById(wins[i].id);
                winsId.push(m.getParamId());
            }

            if (winsId.length > 0) {
                Ext.Ajax.request({
                    url: ExtTrader.updateUrl,
                    params: {
                        modules: Ext.encode(winsId)
                    },
                    scope: this,
                    success: function(result, request) {
                                var jsonData = Ext.decode(result.responseText);
                                for (var win in jsonData) {
                                    app.getModuleById(win).loadData(jsonData[win]);
                                }
                            }
                });
            }
        }
    },

    getModules : function() {
        return [
                new DojoManager.Athletes(),
                new DojoManager.Dojo(),
                new DojoManager.Combat(),
                new DojoManager.About()

            /*,
                new DojoManager.News()*/
            ];
    }
});

Ext.BLANK_IMAGE_URL = 'ext/resources/images/default/s.gif';
